home *** CD-ROM | disk | FTP | other *** search
/ Aminet 1 (Walnut Creek) / Aminet - June 1993 [Walnut Creek].iso / aminet / util / edit / jed207.lha / src / jed.lha / misc.c < prev    next >
C/C++ Source or Header  |  1993-01-05  |  8KB  |  420 lines
  1.  
  2. /*
  3.  * MISC.C
  4.  * (c) 1992-3 J.Harper
  5.  */
  6.  
  7. #include "jed.h"
  8. #include "jed_protos.h"
  9.  
  10. Prototype   STRPTR    stpblk        (STRPTR);
  11. Prototype   LONG    spclen        (STRPTR);
  12. Prototype   STRPTR    stpalnum    (STRPTR);
  13. Prototype   STRPTR    nextdigit    (STRPTR);
  14. Prototype   STRPTR    cpyalnum    (STRPTR, STRPTR);
  15. Prototype   STRPTR    cpynotspc    (STRPTR, STRPTR);
  16. Prototype   STRPTR    savestring    (STRPTR);
  17. Prototype   STRPTR    savestringn    (STRPTR, LONG);
  18. Prototype   STRPTR    squirrelfile    (STRPTR);
  19. Prototype   UBYTE    escchar        (STRPTR *);
  20. Prototype   VOID    NewList        (struct List *list);
  21. Prototype   VALUE *    cmd_format    (LONG, VALUE *);
  22. Prototype   VALUE *    cmd_system    (LONG, VALUE *);
  23. Prototype   VALUE *    cmd_match    (LONG, VALUE *);
  24. Prototype   VOID    killfilereq    (VOID);
  25. Prototype   VALUE *    cmd_freq    (LONG, VALUE *);
  26. Prototype   VALUE *    cmd_atol    (LONG, VALUE *);
  27. Prototype   VALUE *    cmd_substr    (LONG, VALUE *);
  28. Prototype   VALUE *    cmd_car        (LONG, VALUE *);
  29. Prototype   VALUE *    cmd_cdr        (LONG, VALUE *);
  30.  
  31. STRPTR
  32. stpblk(STRPTR str)
  33. {
  34.     while(*str && isspace(*str))
  35.     str++;
  36.     return(str);
  37. }
  38.  
  39. LONG
  40. spclen(STRPTR string)
  41. {
  42.     STRPTR str = string;
  43.     while(*str && isspace(*str))
  44.     str++;
  45.     return((LONG)(str - string));
  46. }
  47.  
  48. STRPTR
  49. stpalnum(STRPTR str)
  50. {
  51.     while(*str && isalnum(*str))
  52.     str++;
  53.     return(str);
  54. }
  55.  
  56. STRPTR
  57. nextdigit(STRPTR str)
  58. {
  59.     while(*str && !isdigit(*str))
  60.     str++;
  61.     return(str);
  62. }
  63.  
  64. STRPTR
  65. cpyalnum(STRPTR dest, STRPTR src)
  66. {
  67.     while(*src && isalnum(*src))
  68.     *dest++ = *src++;
  69.     *dest++ = 0;
  70.     return(dest);
  71. }
  72.  
  73. /*
  74.  * returns the char after the last one copied.
  75.  */
  76. STRPTR
  77. cpynotspc(STRPTR dest, STRPTR src)
  78. {
  79.     while(*src && (!isspace(*src)))
  80.     *dest++ = *src++;
  81.     *dest++ = 0;
  82.     return(src);
  83. }
  84.  
  85. STRPTR
  86. savestring(STRPTR str)
  87. {
  88.     LONG len = strlen(str);
  89.     STRPTR saved = AllocVec(len + 1, 0L);
  90.     if(saved)
  91.     {
  92.     memcpy(saved, str, len);
  93.     saved[len] = 0;
  94.     }
  95.     return(saved);
  96. }
  97.  
  98. /*
  99.  * len doesn't include the zero terminator
  100.  * use the freestring() macro to unalloc this.
  101.  */
  102. STRPTR
  103. savestringn(STRPTR str, LONG len)
  104. {
  105.     STRPTR saved = AllocVec(len + 1, 0L);
  106.     if(saved)
  107.     {
  108.     memcpy(saved, str, len);
  109.     saved[len] = 0;
  110.     }
  111.     return(saved);
  112. }
  113.  
  114. /*
  115.  * use the freestring() macro to release the mem.
  116.  */
  117. STRPTR
  118. squirrelfile(STRPTR fileName)
  119. {
  120.     BPTR fh = Open(fileName, MODE_OLDFILE);
  121.     if(fh)
  122.     {
  123.     ULONG length;
  124.     STRPTR mem;
  125.     Seek(fh, 0, OFFSET_END);
  126.     length = Seek(fh, 0, OFFSET_BEGINNING);
  127.  
  128.     if(mem = AllocVec(length + 1, 0L))
  129.     {
  130.         Read(fh, mem, length);
  131.         mem[length] = 0;
  132.         Close(fh);
  133.         return(mem);
  134.     }
  135.     else
  136.         settitle(NoMemMsg);
  137.     Close(fh);
  138.     }
  139.     return(FALSE);
  140. }
  141.  
  142. /*
  143.  * returns the byte to replace an escape sequence with,
  144.  * str_p is advanced past the last used char
  145.  *
  146.  * supported,
  147.  *  \n
  148.  *  \r
  149.  *  \f
  150.  *  \t
  151.  *  \0Octal
  152.  *  \0xHex
  153.  *  \Decimal
  154.  *
  155.  * anything else is just copied (ie, '\\' equals '\')
  156.  */
  157. UBYTE
  158. escchar(STRPTR *str_p)
  159. {
  160.     STRPTR str = *str_p;
  161.     UBYTE c = *str++;
  162.  
  163.     switch(c)
  164.     {
  165.     case 'n':
  166.         c = '\n';
  167.         break;
  168.     case 'r':
  169.         c = '\r';
  170.         break;
  171.     case 'f':
  172.         c = '\f';
  173.         break;
  174.     case 't':
  175.         c = '\t';
  176.         break;
  177.     default:
  178.         if(isdigit(c))
  179.         {
  180.         c = (UBYTE)strtol(str - 1, str_p, 0);
  181.         str = *str_p;
  182.         }
  183.         break;
  184.     }
  185.     *str_p = str;
  186.     return(c);
  187. }
  188.  
  189. VOID
  190. NewList(struct List *list)
  191. {
  192.     list->lh_Head = (struct Node *)&list->lh_Tail;
  193.     list->lh_Tail = NULL;
  194.     list->lh_TailPred = (struct Node *)&list->lh_Head;
  195. }
  196.  
  197. /*
  198.  * (format `fmtString' args...)
  199.  */
  200. VALUE *
  201. cmd_format(LONG argc, VALUE *argv)
  202. {
  203.     if(TPLATE1(VTF_STRING))
  204.     {
  205.     UBYTE fmtbuff[256];
  206.     LONG i, args[20];
  207.     STRPTR str;
  208.     for(i = 0; (i < (argc - 1)) && (i < 20); i++)
  209.         args[i] = argv[i + 2].val_Value.Number;
  210.     vsprintf(fmtbuff, ARG1.val_Value.String, args);
  211.     if(str = savestring(fmtbuff))
  212.     {
  213.         setstrres(str);
  214.     }
  215.     }
  216.     return(&RES);
  217. }
  218.  
  219. /*
  220.  * (system `AmigaDOS command string')
  221.  */
  222. VALUE *
  223. cmd_system(LONG argc, VALUE *argv)
  224. {
  225.     if(TPLATE1(VTF_STRING))
  226.     {
  227.     setnumres(SystemTags(ARG1.val_Value.String,
  228.         NP_ConsoleTask, NULL,   /* I hope a NULL pr_ConsoleTask is OK */
  229.         TAG_END));
  230.     }
  231.     return(&RES);
  232. }
  233.  
  234. /*
  235.  * (match `wildString' `matchString')
  236.  */
  237. VALUE *
  238. cmd_match(LONG argc, VALUE *argv)
  239. {
  240.     if(TPLATE2(VTF_STRING, VTF_STRING))
  241.     {
  242.     STRPTR parsed;
  243.     LONG bufflen = ((strlen(ARG1.val_Value.String)) << 1) + 2;
  244.     if(parsed = AllocVec(bufflen, 0L))
  245.     {
  246.         if(ParsePatternNoCase(ARG1.val_Value.String, parsed, bufflen) >= 0)
  247.         {
  248.         setnumres(MatchPatternNoCase(parsed, ARG2.val_Value.String));
  249.         }
  250.         else
  251.         settitle("error: pattern won't parse");
  252.         FreeVec(parsed);
  253.     }
  254.     else
  255.         settitle(NoMemMsg);
  256.     }
  257.     return(&RES);
  258. }
  259.  
  260. /*
  261.  * File req stuff.
  262.  * I don't like the ASL requester but I couldn't be bothered to make the DICE
  263.  * libraries for reqtools.library. Use the RTpatch prog to get nice (fast)
  264.  * requesters.
  265.  */
  266.     APTR              AslBase;
  267. Local    struct FileRequester *FileReq;
  268.  
  269. VOID
  270. killfilereq(VOID)
  271. {
  272.     if(FileReq)
  273.     {
  274.     FreeAslRequest(FileReq);
  275.     FileReq = NULL;
  276.     }
  277.     if(AslBase)
  278.     {
  279.     CloseLibrary(AslBase);
  280.     AslBase = NULL;
  281.     }
  282. }
  283.  
  284. /*
  285.  * (freq `r|w' `title' `file')  r|w means read|write
  286.  */
  287. VALUE *
  288. cmd_freq(LONG argc, VALUE *argv)
  289. {
  290.     if(TPLATE3(VTF_STRING, VTF_STRING, VTF_STRING))
  291.     {
  292.     if(AslBase || (AslBase = OpenLibrary("asl.library", 36)))
  293.     {
  294.         if(FileReq || (FileReq = AllocAslRequestTags(ASL_FileRequest, TAG_DONE)))
  295.         {
  296.         WORD flags = 0;
  297.         STRPTR dircopy;
  298.  
  299.         if(toupper(*(ARG1.val_Value.String)) == 'W')
  300.              flags |= FILF_SAVE;
  301.  
  302.         if(dircopy = savestring(ARG3.val_Value.String))
  303.         {
  304.             STRPTR actualfile = FilePart(ARG3.val_Value.String);
  305.             dircopy[actualfile - ARG3.val_Value.String] = 0;
  306.  
  307.             if(AslRequestTags(FileReq,
  308.             ASL_Hail, ARG2.val_Value.String,
  309.             ASL_Window, CurrVW->vw_Window,
  310.             ASL_File, actualfile,
  311.             ASL_Dir, dircopy,
  312.             ASL_FuncFlags, flags,
  313.             TAG_END))
  314.             {
  315.             STRPTR selected;
  316.             LONG sellen = strlen(FileReq->rf_File) + strlen(FileReq->rf_Dir) + 2;
  317.             if(selected = AllocVec(sellen, 0L))
  318.             {
  319.                 strcpy(selected, FileReq->rf_Dir);
  320.                 AddPart(selected, FileReq->rf_File, sellen);
  321.                 setstrres(selected);
  322.             }
  323.             else
  324.                 settitle(NoMemMsg);
  325.             }
  326.             freestring(dircopy);
  327.         }
  328.         else
  329.             settitle(NoMemMsg);
  330.         }
  331.         else
  332.         settitle("error: can't allocate requester");
  333.     }
  334.     else
  335.         settitle("need asl.library");
  336.     }
  337.     return(&RES);
  338. }
  339.  
  340. /*
  341.  * (atol `number-string')
  342.  */
  343. VALUE *
  344. cmd_atol(LONG argc, VALUE *argv)
  345. {
  346.     if(TPLATE1(VTF_STRING))
  347.     {
  348.     APTR dummy;
  349.     setnumres(strtol(ARG1.val_Value.String, &dummy, 0));
  350.     }
  351.     return(&RES);
  352. }
  353.  
  354. /*
  355.  * (substr `str' start length)
  356.  */
  357. VALUE *
  358. cmd_substr(LONG argc, VALUE *argv)
  359. {
  360.     if(TPLATE3(VTF_STRING, VTF_NUMBER, VTF_NUMBER))
  361.     {
  362.     STRPTR ext;
  363.     if(ext = savestringn(ARG1.val_Value.String + ARG2.val_Value.Number, ARG3.val_Value.Number))
  364.     {
  365.         setstrres(ext);
  366.     }
  367.     else
  368.         settitle(NoMemMsg);
  369.     }
  370.     return(&RES);
  371. }
  372.  
  373. /*
  374.  * (car `str' ~sep-char)
  375.  */
  376. VALUE *
  377. cmd_car(LONG argc, VALUE *argv)
  378. {
  379.     if(TPLATE2(VTF_STRING, VTF_NUMBER))
  380.     {
  381.     STRPTR str = ARG1.val_Value.String;
  382.     UBYTE sep = (UBYTE)ARG2.val_Value.Number;
  383.     STRPTR rc;
  384.     while(*str && (*str != sep))
  385.         str++;
  386.     if(rc = savestringn(ARG1.val_Value.String, str - ARG1.val_Value.String))
  387.     {
  388.         setstrres(rc);
  389.     }
  390.     else
  391.         settitle(NoMemMsg);
  392.     }
  393.     return(&RES);
  394. }
  395.  
  396. /*
  397.  * (cdr `str' ~sep-char)
  398.  */
  399. VALUE *
  400. cmd_cdr(LONG argc, VALUE *argv)
  401. {
  402.     if(TPLATE2(VTF_STRING, VTF_NUMBER))
  403.     {
  404.     STRPTR str = ARG1.val_Value.String;
  405.     UBYTE sep = (UBYTE)ARG2.val_Value.Number;
  406.     STRPTR rc;
  407.     while(*str && (*str != sep))
  408.         str++;
  409.     if(*str)
  410.         str++;
  411.     if(rc = savestring(str))
  412.     {
  413.         setstrres(rc);
  414.     }
  415.     else
  416.         settitle(NoMemMsg);
  417.     }
  418.     return(&RES);
  419. }
  420.